#ifndef __HTTP_PARSER_H__
#define __HTTP_PARSER_H__

#include "http.h"
#include "http11_parser.h"
#include "httpclient_parser.h"

namespace johnsonli
{
namespace http
{
    class HttpRequestParser
    {
    public:
        typedef std::shared_ptr<HttpRequestParser> ptr;
        HttpRequestParser();

        /**
        * @brief 解析协议
        * @param[in, out] data 协议文本内存 http request协议
        * @param[in] len 协议文本内存长度
        * @return 返回实际解析的长度,并且将已解析的数据移除
        */
        size_t execute(char* data, size_t len);

        /**
         * @brief 是否解析完成
         * @return 是否解析完成
         */
        int isFinished();

        /**
         * @brief 是否有错误
         * @return 是否有错误
         */
        int hasError(); 

        /**
         * @brief 返回HttpRequest结构体
         */
        HttpRequest::ptr getData() const { return m_data;}

        uint64_t getContentLength();
        static uint64_t GetHttpRequestBufferSize();
        static uint64_t GetHttpRequestMaxBodySize(); 

        void setError(int v) { m_error = v; }

    private:
        http_parser m_parser;       //struct htpp_parser
        HttpRequest::ptr m_data;    //解析后的数据

        /// 1000: invalid method
        /// 1001: invalid version
        /// 1002: invalid field
        int m_error;                //错误码
    };

    class HttpResponseParser
    {
    public:
        typedef std::shared_ptr<HttpResponseParser> ptr;

        HttpResponseParser();

        /**
         * @brief 解析HTTP响应协议
         * @param[in, out] data 协议数据内存 http response协议
         * @param[in] len 协议数据内存大小
         * @param[in] chunck 是否在解析chunck
         * @return 返回实际解析的长度,并且移除已解析的数据
         */
        size_t execute(char* data, size_t len, bool chunck);

        /**
         * @brief 是否解析完成
         */
        int isFinished();

        /**
         * @brief 是否有错误
         */
        int hasError(); 

        /**
         * @brief 返回HttpResponse
         */
        HttpResponse::ptr getData() const { return m_data;}

        uint64_t getContentLength();
        uint64_t GetHttpResponseBufferSize();
        uint64_t GetHttpResponseMaxBodySize(); 
        void setError(int v) { m_error = v; }

        const httpclient_parser& getParser() const { return m_parser;}

    private:
        httpclient_parser m_parser;     //struct httpclient_parser
        HttpResponse::ptr m_data;       //解析后的数据

        /// 1001: invalid version
        /// 1002: invalid field
        int m_error;                    //错误码
    };


}
}

#endif